
//20211002
/**
 * 单向链表两数相加
 * 用linklist或者数组相加减可以解决变量大小的限制
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

 
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
 */

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * 单向链表两数相加
 * 注意：不能把链表换成数字相加，这样会超过数字的大小，需要获取值再一个个相加
 *
 * 解题思路：
 * 1.获取当前的值，然后相加（包含累进数）再获取新的余数和累进数
 * 2.新建一个链表，每次把余数插入到链表的末尾（新建一个插入链表尾部函数）
 * 3.当最后一次的累进数有可能超出时，需要判断再插入到尾端
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
 var addTwoNumbers = function(l1,l2) {
   let sum=0;//当前和
   let carry=0;//累进数
   let current=0;//当前位值
   let sumLink=null;//总和的链表
   while(l1!=null || l2!=null){
      //获取值
      const val1=l1?l1.val:0;
      const val2=l2?l2.val:0;
      //相加值
      sum=val1+val2+carry;
      //获取10进位余数
      current=sum%10;
      //获取进位数
      carry=Math.floor(sum/10);
      //console.log("current",current);
      //添加到链接
      sumLink=addLast(sumLink,current);
      //转到下位
      l1=l1?l1.next:l1;
      l2=l2?l2.next:l2;
   }
   //判断一下尾进数
   if(carry>0){
      sumLink=addLast(sumLink,carry);
   }
   //console.log("sumLink",sumLink);
    return sumLink;
};

function arrToLinkList(arr){
   let linklist=null;
   for (let index = arr.length-1; index >=0 ; index--) {
      linklist=addNode(linklist,arr[index]);
      
   }
   return linklist;
}
function linkListToNumber(link){
   const arr=[];
while(link!=null){
  arr.push(link.val);
  link=link.next;
}
console.log("arr",parseFloat(arr.reverse().join("")));
return parseFloat(arr.reverse().join(""));
}

 function ListNode(val, next) {
     this.val = (val===undefined ? 0 : val)
     this.next = (next===undefined ? null : next)
}

function ListNodeToArr(node){
   const arr=[];
   while(node!=null){
      arr.push(node.val);
      node=node.next;
   }
   return arr;
}
// 从尾部增加
function addLast(link,val){
   const node=new ListNode();
   
   node.val=val;
   node.next=null;
   let phead=link;
  
   if(phead!=null){
      // 判断是否最后一个元素
      while(link.next!=null){
         //移到下个元素，这里不会影响phead，因为改变的是指向新的对象（内存地址）
         link=link.next;
      }
      //设置最后一个元素的下位为新元素，这里会影响phead,因为改变的是对象的值
      link.next=node;
   }else{
      phead=node;
   }
   return phead;
}
// 从头部增加
function addFirst(link,val){
   const node=new ListNode();
   node.val=val;
   node.next=link;
   return node;
}





// let arr=strNumToArr("1234");
// console.log(arr.join(""));
// function strNumToArr(str){
//    return str.split("").reverse();
// }


function test(l1_arr,l2_arr){
   console.log("hi");
   let l1=null;
   for (let index = l1_arr.length-1; index >= 0; index--) {
      l1=addFirst(l1,l1_arr[index]);
   }
let l2=null;
for (let index = l2_arr.length-1; index >= 0; index--) {
   const element = l2_arr[index];
   
   l2=addFirst(l2,l2_arr[index]);
   
}
 
   addTwoNumbers(l1,l2);
}

test([1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],[5,6,4]);

//test( [2,4,3],[5,6,4]);